home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gxclread.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-06-15  |  65.2 KB  |  2,286 lines
  1. /* Copyright (C) 1991, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gxclread.c */
  20. /* Command list reading for Ghostscript. */
  21. #include "memory_.h"
  22. #include "gx.h"
  23. #include "gp.h"                /* for gp_fmode_rb */
  24. #include "gpcheck.h"
  25. #include "gserrors.h"
  26. #include "gsbitops.h"
  27. #include "gsstate.h"            /* (should only be imager state) */
  28. #include "gxdcolor.h"
  29. #include "gxdevice.h"
  30. #include "gscoord.h"            /* requires gsmatrix.h */
  31. #include "gsdevice.h"            /* for gs_deviceinitialmatrix */
  32. #include "gxdevmem.h"            /* must precede gxcldev.h */
  33. #include "gxcldev.h"
  34. #include "gxclpath.h"
  35. #include "gxcmap.h"
  36. #include "gxcspace.h"            /* for gs_color_space_type */
  37. #include "gxpaint.h"            /* for gx_fill/stroke_params */
  38. #include "gxhttile.h"
  39. #include "gdevht.h"
  40. #include "gzpath.h"
  41. #include "gzcpath.h"
  42. #include "gzacpath.h"
  43. #include "stream.h"
  44. #include "strimpl.h"
  45.  
  46. /* We need color space types for constructing temporary color spaces. */
  47. extern const gs_color_space_type gs_color_space_type_Indexed;
  48.  
  49. #define cdev crdev
  50.  
  51. /* Print a bitmap for tracing */
  52. #ifdef DEBUG
  53. private void
  54. cmd_print_bits(const byte *data, int width, int height, int raster)
  55. {    int i, j;
  56.     dprintf3("[L]width=%d, height=%d, raster=%d\n",
  57.          width, height, raster);
  58.     for ( i = 0; i < height; i++ )
  59.        {    const byte *row = data + i * raster;
  60.         dprintf("[L]");
  61.         for ( j = 0; j < raster; j++ )
  62.           dprintf1(" %02x", row[j]);
  63.         dputc('\n');
  64.        }
  65. }
  66. #else
  67. #  define cmd_print_bits(data, width, height, raster) DO_NOTHING
  68. #endif
  69.  
  70. /* ------ Band file reading stream ------ */
  71.  
  72. /*
  73.  * To separate banding per se from command list interpretation,
  74.  * we make the command list interpreter simply read from a stream.
  75.  * When we are actually doing banding, the stream filters the band file
  76.  * and only passes through the commands for the current band (or band
  77.  * ranges that include the current band).
  78.  */
  79. typedef struct stream_band_read_state_s {
  80.     stream_state_common;
  81.     gx_band_page_info page_info;
  82.     int band;
  83.     uint left;        /* amount of data left in this run */
  84.     cmd_block b_this;
  85. } stream_band_read_state;
  86.  
  87. #define ss ((stream_band_read_state *)st)
  88.  
  89. private int
  90. s_band_read_init(stream_state *st)
  91. {    ss->left = 0;
  92.     ss->b_this.band_min = 0;
  93.     ss->b_this.band_max = 0;
  94.     ss->b_this.pos = 0;
  95.     clist_rewind(ss->page_bfile, false, ss->page_bfname);
  96.     return 0;
  97. }
  98.  
  99. private int
  100. s_band_read_process(stream_state *st, stream_cursor_read *ignore_pr,
  101.   stream_cursor_write *pw, bool last)
  102. {    register byte *q = pw->ptr;
  103.     byte *wlimit = pw->limit;
  104.     clist_file_ptr cfile = ss->page_cfile;
  105.     clist_file_ptr bfile = ss->page_bfile;
  106.     uint left = ss->left;
  107.     int status = 1;
  108.     uint count;
  109.  
  110.     while ( (count = wlimit - q) != 0 )
  111.       {    if ( left )
  112.           {    /* Read more data for the current run. */
  113.             if ( count > left )
  114.               count = left;
  115.             clist_fread_chars(q + 1, count, cfile);
  116.             if ( clist_ferror_code(cfile) < 0 )
  117.               { status = ERRC;
  118.                 break;
  119.               }
  120.             q += count;
  121.             left -= count;
  122.             process_interrupts();
  123.             continue;
  124.           }
  125. rb:        /* Scan for the next run for this band (or a band range */
  126.         /* that includes the current band). */
  127.         if ( ss->b_this.band_min == cmd_band_end &&
  128.              clist_ftell(bfile) == ss->page_bfile_end_pos
  129.            )
  130.           { status = EOFC;
  131.             break;
  132.           }
  133.         { int bmin = ss->b_this.band_min;
  134.           int bmax = ss->b_this.band_max;
  135.           long pos = ss->b_this.pos;
  136.  
  137.           clist_fread_chars(&ss->b_this, sizeof(ss->b_this), bfile);
  138.           if ( !(ss->band >= bmin && ss->band <= bmax) )
  139.             goto rb;
  140.           clist_fseek(cfile, pos, SEEK_SET, ss->page_cfname);
  141.           left = (uint)(ss->b_this.pos - pos);
  142.           if_debug5('l', "[l]reading for bands (%d,%d) at bfile %ld, cfile %ld, length %u\n",
  143.                 bmin, bmax,
  144.                 clist_ftell(bfile) - 2 * sizeof(ss->b_this),
  145.                 pos, left);
  146.         }
  147.       }
  148.     pw->ptr = q;
  149.     ss->left = left;
  150.     return status;
  151. }
  152.  
  153. #undef ss
  154.  
  155. /* Stream template */
  156. const stream_template s_band_read_template =
  157. {    &st_stream_state, s_band_read_init, s_band_read_process, 1, cbuf_size
  158. };
  159.  
  160.  
  161. /* ------ Reading/rendering ------ */
  162.  
  163. private int clist_render_init(P2(gx_device_clist *, gx_device_ht *));
  164. private int clist_render_band(P6(gx_device_clist_reader *, stream *, gx_device *, int, int, gs_memory_t *));
  165.  
  166. /* Copy a scan line to the client.  This is where rendering gets done. */
  167. int
  168. clist_get_bits(gx_device *dev, int y, byte *str, byte **actual_data)
  169. {    gx_device *target = cdev->target;
  170.     uint raster = gx_device_raster(target, 1);
  171.     byte *mdata = cdev->data + cdev->page_tile_cache_size;
  172.     gx_device_memory mdev;
  173.     gx_device_ht hdev;
  174.     gx_device *tdev = (gx_device *)&mdev;
  175.  
  176.     /* Initialize for rendering if we haven't done so yet. */
  177.     if ( cdev->ymin < 0 )
  178.     {    int code = clist_render_init((gx_device_clist *)dev, &hdev);
  179.         if ( code < 0 )
  180.           return code;
  181.         if ( code != 0 )
  182.           { hdev.target = tdev;
  183.             tdev = (gx_device *)&hdev;
  184.           }
  185.     }
  186.     /* Render a band if necessary, and copy it incrementally. */
  187.     if ( !(y >= cdev->ymin && y < cdev->ymax) )
  188.        {    int band_height = cdev->page_band_height;
  189.         int band = y / band_height;
  190.         const gx_placed_page *ppages = cdev->pages;
  191.         int num_pages = cdev->num_pages;
  192.         gx_saved_page current_page;
  193.         gx_placed_page placed_page;
  194.         /* We have to pick some allocator for rendering.... */
  195.         gs_memory_t *mem =
  196.           (cdev->memory != 0 ? cdev->memory : &gs_memory_default);
  197.         stream_band_read_state rs;
  198.         int i;
  199.         int code;
  200.         private const stream_procs no_procs =
  201.           {    s_std_noavailable, s_std_noseek, s_std_read_reset,
  202.             s_std_read_flush, s_std_close, s_band_read_process
  203.           };
  204.  
  205.         if ( y < 0 || y > dev->height )
  206.           return_error(gs_error_rangecheck);
  207.         code = (*cdev->make_buffer_device)(&mdev, target, 0, true);
  208.         if ( code < 0 )
  209.           return code;
  210.         /****** QUESTIONABLE, BUT BETTER THAN OMITTING ******/
  211.         mdev.color_info = dev->color_info;
  212.         mdev.base = mdata;
  213.         rs.template = &s_band_read_template;
  214.         rs.memory = 0;
  215.         rs.band = band;
  216.         /*
  217.          * The matrix in the memory device is irrelevant,
  218.          * because all we do with the device is call the device-level
  219.          * output procedures, but we may as well set it to
  220.          * something halfway reasonable.
  221.          */
  222.         gs_deviceinitialmatrix(target, &mdev.initial_matrix);
  223.         mdev.width = target->width;
  224.         mdev.height = band_height;
  225.         mdev.raster = raster;
  226.         (*dev_proc(&mdev, open_device))((gx_device *)&mdev);
  227.         if_debug1('l', "[l]rendering band %d\n", band);
  228.         /*
  229.          * If we aren't rendering saved pages, do the current one.
  230.          * Note that this is the only case in which we may encounter
  231.          * a gx_saved_page with non-zero cfile or bfile.
  232.          */
  233.         if ( ppages == 0 )
  234.           { current_page.info = cdev->page_info;
  235.             placed_page.page = ¤t_page;
  236.             placed_page.offset.x = placed_page.offset.y = 0;
  237.             ppages = &placed_page;
  238.             num_pages = 1;
  239.           }
  240.         for ( i = 0; i < num_pages; ++i )
  241.           { const gx_placed_page *ppage = &ppages[i];
  242.  
  243.             rs.page_info = ppage->page->info;
  244.             /* If this is a saved page, open the files. */
  245.             if ( (rs.page_cfile != 0 ||
  246.               (code = clist_fopen(rs.page_cfname, gp_fmode_rb,
  247.                           &rs.page_cfile, mem, true)) >= 0) &&
  248.              (rs.page_bfile != 0 ||
  249.               (code = clist_fopen(rs.page_bfname, gp_fmode_rb,
  250.                           &rs.page_bfile, mem, false)) >= 0)
  251.                )
  252.               { stream s;
  253.                 byte sbuf[cbuf_size];
  254.  
  255.                 s_band_read_init((stream_state *)&rs);
  256.                 s_std_init(&s, sbuf, cbuf_size, &no_procs, s_mode_read);
  257.             s.foreign = 1;
  258.             s.state = (stream_state *)&rs;
  259.             code = clist_render_band(cdev, &s, tdev,
  260.                          -ppage->offset.x,
  261.                          band * mdev.height, mem);
  262.               }
  263.             /* Close the files if we just opened them. */
  264.             if ( ppage->page->info.bfile == 0 && rs.page_bfile != 0 )
  265.               clist_fclose(rs.page_bfile, rs.page_bfname, false);
  266.             if ( ppage->page->info.cfile == 0 && rs.page_cfile != 0 )
  267.               clist_fclose(rs.page_cfile, rs.page_cfname, false);
  268.             if ( code < 0 )
  269.               break;
  270.           }
  271.         /* Reset the band boundaries now, so that we don't get */
  272.         /* an infinite loop. */
  273.         cdev->ymin = band * mdev.height;
  274.         cdev->ymax = cdev->ymin + mdev.height;
  275.         if ( cdev->ymax > dev->height )
  276.           cdev->ymax = dev->height;
  277.         if ( code < 0 )
  278.           return code;
  279.        }
  280.     { byte *src = mdata + (y - cdev->ymin) * raster;
  281.       if ( actual_data == 0 )
  282.         memcpy(str, src, gx_device_raster(dev, 0));
  283.       else
  284.         *actual_data = src;
  285.     }
  286.     return 0;
  287. }
  288.  
  289. /* Initialize for reading. */
  290. private int
  291. clist_render_init(gx_device_clist *dev, gx_device_ht *hdev)
  292. {    int code = clist_end_page(&dev->writer);
  293.  
  294.     if ( code < 0 )
  295.       return code;
  296.     cdev->ymin = cdev->ymax = 0;
  297.     /* For normal rasterizing, pages and num_pages are zero. */
  298.     cdev->pages = 0;
  299.     cdev->num_pages = 0;
  300.     return 0;
  301. }
  302.  
  303. #undef cdev
  304.  
  305. /* Get a variable-length integer operand. */
  306. #define cmd_getw(var, p)\
  307.   do\
  308.    { if ( *p < 0x80 ) var = *p++;\
  309.      else { const byte *_cbp; var = cmd_get_w(p, &_cbp); p = _cbp; }\
  310.    }\
  311.   while (0)
  312. private long near
  313. cmd_get_w(const byte *p, const byte **rp)
  314. {    long val = *p++ & 0x7f;
  315.     int shift = 7;
  316.     for ( ; val += (long)(*p & 0x7f) << shift, *p++ > 0x7f; shift += 7 )
  317.       ;
  318.     *rp = p;
  319.     return val;
  320. }
  321.  
  322. /* Render one band to a specified target device. */
  323. private const byte *cmd_read_rect(P3(int, gx_cmd_rect *, const byte *));
  324. private const byte *cmd_read_matrix(P2(gs_matrix *, const byte *));
  325. private void clist_unpack_short_bits(P5(byte *, const byte *, int, int, uint));
  326. private int cmd_select_map(P7(cmd_map_index, bool, gs_imager_state *,
  327.                   gx_ht_order *, frac **, uint *, gs_memory_t *));
  328. private int cmd_resize_halftone(P3(gx_device_halftone *, uint, gs_memory_t *));
  329. private int cmd_install_ht_order(P3(gx_ht_order *, const gx_ht_order *,
  330.                     gs_memory_t *));
  331. private int clist_decode_segment(P7(gx_path *, int, fixed [6],
  332.                     gs_fixed_point *, int, int,
  333.                     segment_notes));
  334. private int
  335. clist_render_band(gx_device_clist_reader *cdev, stream *s, gx_device *target,
  336.   int x0, int y0, gs_memory_t *mem)
  337. {    byte cbuf[cbuf_size];
  338.         /* data_bits is for short copy_* bits and copy_* compressed, */
  339.         /* must be aligned */
  340. #define data_bits_size cbuf_size
  341.     byte *data_bits;
  342.     register const byte *cbp;
  343.     const byte *cb_limit;
  344.     const byte *cb_end;
  345.     int end_status = 0;
  346.     int dev_depth = cdev->color_info.depth;
  347.     int dev_depth_bytes = (dev_depth + 7) >> 3;
  348.     gx_device *tdev;
  349.     gx_clist_state state;
  350.     gx_color_index _ss *set_colors;
  351.     tile_slot *state_slot;
  352.     gx_strip_bitmap state_tile;    /* parameters for reading tiles */
  353.     tile_slot tile_bits;        /* parameters of current tile */
  354.     gs_int_point tile_phase;
  355.     gx_path path;
  356.     bool in_path;
  357.     gs_fixed_point ppos;
  358.     gx_clip_path clip_path;
  359.     bool use_clip;
  360.     gx_clip_path *pcpath;
  361.     gx_device_cpath_accum clip_accum;
  362.     gs_fixed_rect target_box;
  363.     struct _cas {
  364.       bool lop_enabled;
  365.       gs_fixed_point fill_adjust;
  366.     } clip_save;
  367.     gs_imager_state imager_state;
  368.     gx_device_color dev_color;
  369.     float dash_pattern[cmd_max_dash];
  370.     gx_fill_params fill_params;
  371.     gx_stroke_params stroke_params;
  372.     gx_device_halftone dev_ht;
  373.     gs_halftone_type halftone_type;
  374.     gx_ht_order *porder;
  375.     uint ht_data_index;
  376.     gs_image_t image;
  377.     int image_num_planes;
  378.     gs_int_rect image_rect;
  379.     gs_color_space color_space;    /* only used for indexed spaces */
  380.     const gs_color_space *pcs;
  381.     void *image_info;
  382.     segment_notes notes;
  383.     int data_x;
  384.     int code = 0;
  385.  
  386. #define cmd_get_value(var, cbp)\
  387.   memcpy(&var, cbp, sizeof(var));\
  388.   cbp += sizeof(var)
  389. #define cmd_read(ptr, rsize, cbp)\
  390.   if ( cb_end - cbp >= (rsize) )\
  391.     memcpy(ptr, cbp, rsize), cbp += rsize;\
  392.   else\
  393.    { uint cleft = cb_end - cbp, rleft = (rsize) - cleft;\
  394.      memcpy(ptr, cbp, cleft);\
  395.      sgets(s, ptr + cleft, rleft, &rleft);\
  396.      cbp = cb_end;\
  397.    }
  398. #define cmd_read_short_bits(ptr, bw, ht, ras, cbp)\
  399.   cmd_read(ptr, (bw) * (ht), cbp);\
  400.   clist_unpack_short_bits(ptr, ptr, bw, ht, ras)
  401.  
  402.     cb_limit = cbuf + (cbuf_size - cmd_largest_size + 1);
  403.     cb_end = cbuf + cbuf_size;
  404.     cbp = cb_end;
  405. in:    /* Initialize for a new page. */
  406.     tdev = target;
  407.     set_colors = state.colors;
  408.     use_clip = false;
  409.     pcpath = NULL;
  410.     notes = sn_none;
  411.     data_x = 0;
  412.     { static const gx_clist_state cls_initial = { cls_initial_values };
  413.       state = cls_initial;
  414.     }
  415.     state_tile.id = gx_no_bitmap_id;
  416.     state_tile.shift = state_tile.rep_shift = 0;
  417.     tile_phase.x = tile_phase.y = 0;
  418.     gx_path_init(&path, mem);
  419.     in_path = false;
  420.     /*
  421.      * Initialize the clipping region to the full page.
  422.      * (Since we also initialize use_clip to false, this is arbitrary.)
  423.      */
  424.     { gs_fixed_rect cbox;
  425.       cbox.p.x = 0;
  426.       cbox.p.y = 0;
  427.       cbox.q.x = cdev->width;
  428.       cbox.q.y = cdev->height;
  429.       gx_cpath_from_rectangle(&clip_path, &cbox, mem);
  430.     }
  431.     (*dev_proc(target, get_clipping_box))(target, &target_box);
  432.     imager_state = clist_imager_state_initial;
  433.     imager_state.line_params.dash.pattern = dash_pattern;
  434.     code = gs_imager_state_initialize(&imager_state, mem);
  435.     if ( code < 0 )
  436.       goto out;
  437.     imager_state.halftone = 0;    /* never referenced */
  438.     memset(&dev_ht, 0, sizeof(dev_ht));
  439.     dev_ht.order.levels = 0;  /* clear pointers explicitly, just in case */
  440.     dev_ht.order.bits = 0;
  441.     dev_ht.order.transfer = 0;
  442.     dev_ht.components = 0;
  443.     imager_state.dev_ht = &dev_ht;
  444.     imager_state.ht_cache = 0;
  445.     gx_set_cmap_procs(&imager_state, tdev);
  446.     gx_imager_setscreenphase(&imager_state, -x0, -y0, gs_color_select_all);
  447.     halftone_type = ht_type_none;
  448.     fill_params.fill_zero_width = false;
  449.     pcs = gs_color_space_DeviceGray();
  450.     data_bits = gs_alloc_bytes(mem, data_bits_size,
  451.                    "clist_render_band(data_bits)");
  452.     if ( data_bits == 0 )
  453.       { code = gs_note_error(gs_error_VMerror);
  454.         goto out;
  455.       }
  456.     while ( code >= 0 )
  457.        {    int op;
  458.         int compress, depth, raster;
  459.         byte *source;
  460.         gx_color_index colors[2];
  461.         gx_color_index _ss *pcolor;
  462.         gs_logical_operation_t log_op;
  463.         tile_slot bits;        /* parameters for reading bits */
  464.  
  465.         /* Make sure the buffer contains a full command. */
  466. #define set_cb_end(p)\
  467.   cb_end = p;\
  468.   cb_limit = cbuf + (cbuf_size - cmd_largest_size + 1);\
  469.   if ( cb_limit > cb_end ) cb_limit = cb_end
  470.         if ( cbp >= cb_limit )
  471.         {    if ( end_status < 0 )
  472.               {    /* End of file or error. */
  473.                 if ( cbp == cb_end )
  474.                   { code = (end_status == EOFC ? 0 :
  475.                         gs_note_error(gs_error_ioerror));
  476.                     break;
  477.                   }
  478.               }
  479.             else
  480.               {    uint nread;
  481.                 byte *cb_top = cbuf + (cb_end - cbp);
  482.  
  483.                 memmove(cbuf, cbp, cb_end - cbp);
  484.                 nread = cb_end - cb_top;
  485.                 end_status = sgets(s, cb_top, nread, &nread);
  486.                 if ( nread == 0 )
  487.                   { /* No data for this band at all. */
  488.                     *cb_top = cmd_opv_end_run;
  489.                     nread = 1;
  490.                   }
  491.                 set_cb_end(cb_top + nread);
  492.                 cbp = cbuf;
  493.                 process_interrupts();
  494.               }
  495.         }
  496.         op = *cbp++;
  497. #ifdef DEBUG
  498.         if ( gs_debug_c('L') )
  499.           { const char **sub = cmd_sub_op_names[op >> 4];
  500.             if ( sub )
  501.               dprintf1("[L]%s:", sub[op & 0xf]);
  502.             else
  503.               dprintf2("[L]%s %d:", cmd_op_names[op >> 4], op & 0xf);
  504.           }
  505. #endif
  506.         switch ( op >> 4 )
  507.            {
  508.         case cmd_op_misc >> 4:
  509.             switch ( op )
  510.                {
  511.             case cmd_opv_end_run:
  512.                 if_debug0('L', "\n");
  513.                 continue;
  514.             case cmd_opv_set_tile_size:
  515.               {    uint rep_width, rep_height;
  516.                 byte bd = *cbp++;
  517.  
  518.                 tile_bits.cb_depth = (bd & 31) + 1;
  519.                 cmd_getw(rep_width, cbp);
  520.                 cmd_getw(rep_height, cbp);
  521.                 if ( bd & 0x20 ) {
  522.                   cmd_getw(tile_bits.x_reps, cbp);
  523.                   tile_bits.width =
  524.                     rep_width * tile_bits.x_reps;
  525.                 } else {
  526.                   tile_bits.x_reps = 1,
  527.                     tile_bits.width = rep_width;
  528.                 }
  529.                 if ( bd & 0x40 ) {
  530.                   cmd_getw(tile_bits.y_reps, cbp);
  531.                   tile_bits.height =
  532.                     rep_height * tile_bits.y_reps;
  533.                 } else {
  534.                   tile_bits.y_reps = 1,
  535.                     tile_bits.height = rep_height;
  536.                 }
  537.                 if ( bd & 0x80 )
  538.                   cmd_getw(tile_bits.rep_shift, cbp);
  539.                 else
  540.                   tile_bits.rep_shift = 0;
  541.                 if_debug6('L', " depth=%d size=(%d,%d), rep_size=(%d,%d), rep_shift=%d\n",
  542.                       tile_bits.cb_depth, tile_bits.width,
  543.                       tile_bits.height, rep_width,
  544.                       rep_height, tile_bits.rep_shift);
  545.                 tile_bits.shift =
  546.                   (tile_bits.rep_shift == 0 ? 0 :
  547.                    (tile_bits.rep_shift *
  548.                     (tile_bits.height / rep_height))
  549.                    % rep_width);
  550.                 tile_bits.cb_raster =
  551.                   bitmap_raster(tile_bits.width *
  552.                         tile_bits.cb_depth);
  553.               }    continue;
  554.             case cmd_opv_set_tile_phase:
  555.                 cmd_getw(state.tile_phase.x, cbp);
  556.                 cmd_getw(state.tile_phase.y, cbp);
  557.                 if_debug2('L', " (%d,%d)\n",
  558.                       state.tile_phase.x,
  559.                       state.tile_phase.y);
  560.                 goto set_phase;
  561.             case cmd_opv_set_tile_bits:
  562.                 bits = tile_bits;
  563.                 compress = 0;
  564. stb:                { uint rep_width = bits.width / bits.x_reps;
  565.                   uint rep_height = bits.height / bits.y_reps;
  566.                   uint index;
  567.                   ulong offset;
  568.                   uint width_bits = rep_width * bits.cb_depth;
  569.                   uint width_bytes;
  570.                   uint bytes =
  571.                     clist_bitmap_bytes(width_bits, rep_height,
  572.                         compress |
  573.                         (rep_width < bits.width ?
  574.                          decompress_spread : 0) |
  575.                         decompress_elsewhere,
  576.                         &width_bytes,
  577.                         (uint *)&raster);
  578.                   byte *data;
  579.  
  580.                   cmd_getw(index, cbp);
  581.                   cmd_getw(offset, cbp);
  582.                   if_debug2('L', " index=%d offset=%lu\n",
  583.                         state.tile_index, offset);
  584.                   state.tile_index = index;
  585.                   cdev->tile_table[state.tile_index].offset =
  586.                     offset;
  587.                   state_slot =
  588.                     (tile_slot *)(cdev->chunk.data + offset);
  589.                   *state_slot = bits;
  590.                   state_tile.data = data =
  591.                     (byte *)(state_slot + 1);
  592. #ifdef DEBUG
  593.                   state_slot->index = state.tile_index;
  594. #endif
  595.                   if ( compress )
  596.                     { /* Decompress the image data. */
  597.                       /* We'd like to share this code */
  598.                       /* with the similar code in copy_*, */
  599.                       /* but right now we don't see how. */
  600.                       stream_cursor_read r;
  601.                       stream_cursor_write w;
  602.                       /* We don't know the data length a */
  603.                       /* priori, so to be conservative, */
  604.                       /* we read the uncompressed size. */
  605.                       uint cleft = cb_end - cbp;
  606.  
  607.                       if ( cleft < bytes )
  608.                     { uint nread = cbuf_size - cleft;
  609.                       memmove(cbuf, cbp, cleft);
  610.                       end_status = sgets(s, cbuf + cleft, nread, &nread);
  611.                       set_cb_end(cbuf + cleft + nread);
  612.                       cbp = cbuf;
  613.                     }
  614.                       r.ptr = cbp - 1;
  615.                       r.limit = cb_end - 1;
  616.                       w.ptr = data - 1;
  617.                       w.limit = w.ptr + bytes;
  618.                       switch ( compress )
  619.                     {
  620.                     case cmd_compress_rle: 
  621.                       { stream_RLD_state sstate;
  622.                         clist_rld_init(&sstate);
  623.                         (*s_RLD_template.process)
  624.                           ((stream_state *)&sstate, &r, &w, true);
  625.                       } break;
  626.                     case cmd_compress_cfe:
  627.                       { stream_CFD_state sstate;
  628.                         clist_cfd_init(&sstate,
  629.                                width_bytes << 3 /*width_bits*/,
  630.                                rep_height);
  631.                         (*s_CFD_template.process)
  632.                           ((stream_state *)&sstate, &r, &w, true);
  633.                         (*s_CFD_template.release)
  634.                           ((stream_state *)&sstate);
  635.                       } break;
  636.                     default:
  637.                       goto bad_op;
  638.                     }
  639.                       cbp = r.ptr + 1;
  640.                     }
  641.                   else if ( rep_height > 1 &&
  642.                         width_bytes != bits.cb_raster
  643.                       )
  644.                     {    cmd_read_short_bits(data, width_bytes,
  645.                       rep_height, bits.cb_raster, cbp);
  646.                     }
  647.                   else
  648.                     {    cmd_read(data, bytes, cbp);
  649.                     }
  650.                   if ( bits.width > rep_width )
  651.                     bits_replicate_horizontally(data,
  652.                       rep_width * bits.cb_depth, rep_height,
  653.                       bits.cb_raster,
  654.                       bits.width * bits.cb_depth,
  655.                       bits.cb_raster);
  656.                   if ( bits.height > rep_height )
  657.                     bits_replicate_vertically(data,
  658.                       rep_height, bits.cb_raster,
  659.                       bits.height);
  660. #ifdef DEBUG
  661.                   if ( gs_debug_c('L') )
  662.                     cmd_print_bits(data, bits.width,
  663.                            bits.height,
  664.                            bits.cb_raster);
  665. #endif
  666.                 }
  667.                 goto stp;
  668.             case cmd_opv_set_bits:
  669.                 compress = *cbp & 3;
  670.                 bits.cb_depth = *cbp++ >> 2;
  671.                 cmd_getw(bits.width, cbp);
  672.                 cmd_getw(bits.height, cbp);
  673.                 if_debug4('L', " compress=%d depth=%d size=(%d,%d)",
  674.                       compress, bits.cb_depth,
  675.                       bits.width, bits.height);
  676.                 bits.cb_raster =
  677.                   bitmap_raster(bits.width * bits.cb_depth);
  678.                 bits.x_reps = bits.y_reps = 1;
  679.                 bits.shift = bits.rep_shift = 0;
  680.                 goto stb;
  681.             case cmd_opv_set_tile_color:
  682.                 set_colors = state.tile_colors;
  683.                 if_debug0('L', "\n");
  684.                 continue;
  685.             case cmd_opv_set_misc:
  686.               {    uint cb = *cbp++;
  687.                 switch ( cb >> 6 )
  688.                   {
  689.                   case cmd_set_misc_lop >> 6:
  690.                     cmd_getw(state.lop, cbp);
  691.                     state.lop = (state.lop << 6) + (cb & 0x3f);
  692.                     if_debug1('L', " lop=0x%x\n", state.lop);
  693.                     if ( state.lop_enabled )
  694.                       imager_state.log_op = state.lop;
  695.                     break;
  696.                   case cmd_set_misc_data_x >> 6:
  697.                     if ( cb & 0x20 )
  698.                       cmd_getw(data_x, cbp);
  699.                     else
  700.                       data_x = 0;
  701.                     data_x = (data_x << 5) + (cb & 0x1f);
  702.                     if_debug1('L', " data_x=%d\n", data_x);
  703.                     break;
  704.                   case cmd_set_misc_map >> 6:
  705.                     { frac *mdata;
  706.                       uint count;
  707.                       code = cmd_select_map(cb & 0x1f,
  708.                                 cb & 0x20,
  709.                                 &imager_state,
  710.                                 porder, &mdata,
  711.                                 &count, mem);
  712.  
  713.                       if ( code < 0 )
  714.                     goto out;
  715.                       if ( mdata )
  716.                     { cmd_read((byte *)mdata, count, cbp);
  717. #ifdef DEBUG
  718.                       if ( gs_debug_c('L') )
  719.                         { uint i;
  720.                           for ( i = 0; i < count / sizeof(*mdata); ++i )
  721.                         dprintf1(" 0x%04x", mdata[i]);
  722.                           dputc('\n');
  723.                         }
  724.                     }
  725.                       else
  726.                     { if_debug0('L', " none\n");
  727. #endif
  728.                     }
  729.                     }
  730.                     /* Recompute the effective transfer, */
  731.                     /* in case this was a transfer map. */
  732.                     gx_imager_set_effective_xfer(
  733.                     &imager_state);
  734.                     break;
  735.                   case cmd_set_misc_halftone >> 6:
  736.                     halftone_type = cb & 0x3f;
  737.                     { uint num_comp;
  738.                       cmd_getw(num_comp, cbp);
  739.                       if_debug2('L', " halftone type=%d num_comp=%u\n",
  740.                         halftone_type, num_comp);
  741.                       code = cmd_resize_halftone(&dev_ht,
  742.                         num_comp, mem);
  743.                       if ( code < 0 )
  744.                     goto out;
  745.                     }
  746.                     break;
  747.                   default:
  748.                     goto bad_op;
  749.                   }
  750.               }
  751.                 continue;
  752.             case cmd_opv_enable_lop:
  753.                 state.lop_enabled = true;
  754.                 imager_state.log_op = state.lop;
  755.                 if_debug0('L', "\n");
  756.                 continue;
  757.             case cmd_opv_disable_lop:
  758.                 state.lop_enabled = false;
  759.                 imager_state.log_op = lop_default;
  760.                 if_debug0('L', "\n");
  761.                 continue;
  762.             case cmd_opv_set_ht_order:
  763.                  { int index;
  764.                    gx_ht_order order;
  765.  
  766.                    cmd_getw(index, cbp);
  767.                    if ( index == 0 )
  768.                  porder = &dev_ht.order;
  769.                    else
  770.                  { gx_ht_order_component *pcomp =
  771.                      &dev_ht.components[index - 1];
  772.                    cmd_getw(pcomp->cname, cbp);
  773.                    if_debug1('L', " cname=%lu",
  774.                          (ulong)pcomp->cname);
  775.                    porder = &pcomp->corder;
  776.                  }
  777.                    order = *porder;
  778.                    cmd_getw(order.width, cbp);
  779.                    cmd_getw(order.height, cbp);
  780.                    cmd_getw(order.raster, cbp);
  781.                    cmd_getw(order.shift, cbp);
  782.                    cmd_getw(order.num_levels, cbp);
  783.                    cmd_getw(order.num_bits, cbp);
  784.                    if_debug7('L', " index=%d size=(%d,%d) raster=%d shift=%d num_levels=%d num_bits=%d\n",
  785.                      index, order.width, order.height,
  786.                      order.raster, order.shift,
  787.                      order.num_levels, order.num_bits);
  788.                    code =
  789.                  cmd_install_ht_order(porder, &order, mem);
  790.                    if ( code < 0 )
  791.                  goto out;
  792.                  }
  793.                  ht_data_index = 0;
  794.                  continue;
  795.             case cmd_opv_set_ht_data:
  796.                 { int n = *cbp++;
  797.                   if ( ht_data_index < porder->num_levels )
  798.                     { /* Setting levels */
  799.                       byte *lptr = (byte *)
  800.                     (porder->levels + ht_data_index);
  801.                       cmd_read(lptr, n * sizeof(*porder->levels),
  802.                            cbp);
  803. #ifdef DEBUG
  804.                       if ( gs_debug_c('L') )
  805.                     { int i;
  806.                       dprintf1(" levels[%u]", ht_data_index);
  807.                       for ( i = 0; i < n; ++i )
  808.                         dprintf1(" %u",
  809.                              porder->levels[ht_data_index + i]);
  810.                       dputc('\n');
  811.                     }
  812. #endif
  813.                     }
  814.                   else
  815.                     { /* Setting bits */
  816.                       byte *bptr = (byte *)
  817.                     (porder->bits +
  818.                      (ht_data_index - porder->num_levels));
  819.                       cmd_read(bptr, n * sizeof(*porder->bits),
  820.                            cbp);
  821. #ifdef DEBUG
  822.                       if ( gs_debug_c('L') )
  823.                     { int i;
  824.                       dprintf1(" bits[%u]", ht_data_index - porder->num_levels);
  825.                       for ( i = 0; i < n; ++i )
  826.                         { const gx_ht_bit *pb =
  827.                         &porder->bits[ht_data_index - porder->num_levels + i];
  828.                           dprintf2(" (%u,0x%lx)",
  829.                                pb->offset,
  830.                                (ulong)pb->mask);
  831.                         }
  832.                       dputc('\n');
  833.                     }
  834. #endif
  835.                     }
  836.                   ht_data_index += n;
  837.                 }
  838.                 /* If this is the end of the data, */
  839.                 /* install the (device) halftone. */
  840.                 if ( porder ==
  841.                        (dev_ht.components != 0 ?
  842.                     &dev_ht.components[0].corder :
  843.                     &dev_ht.order) &&
  844.                      ht_data_index == porder->num_levels +
  845.                      porder->num_bits
  846.                    )
  847.                   { /* Make sure we have a halftone cache. */
  848.                     uint i;
  849.                     if ( imager_state.ht_cache == 0 )
  850.                       { gx_ht_cache *pcache =
  851.                       gx_ht_alloc_cache(mem,
  852.                         porder->num_levels + 2,
  853.                         gx_ht_cache_default_bits());
  854.                         if ( pcache == 0 )
  855.                       { code = gs_note_error(gs_error_VMerror);
  856.                         goto out;
  857.                       }
  858.                     imager_state.ht_cache = pcache;
  859.                       }
  860.                     for ( i = 1; i < dev_ht.num_comp; ++i )
  861.                       { gx_ht_order *pco =
  862.                       &dev_ht.components[i].corder;
  863.                         if ( !pco->cache )
  864.                       { gx_ht_cache *pcache =
  865.                           gx_ht_alloc_cache(mem, 1,
  866.                         pco->raster * (pco->num_bits /
  867.                                    pco->width));
  868.                         if ( pcache == 0 )
  869.                           { code = gs_note_error(gs_error_VMerror);
  870.                             goto out;
  871.                           }
  872.                         pco->cache = pcache;
  873.                         gx_ht_init_cache(pcache, pco);
  874.                       }
  875.                     }
  876.                     if ( dev_ht.num_comp )
  877.                       { dev_ht.components[0].corder.cache =
  878.                       imager_state.ht_cache;
  879.                         dev_ht.order =
  880.                       dev_ht.components[0].corder;
  881.                       }
  882.                     gx_imager_dev_ht_install(&imager_state,
  883.                     &dev_ht, halftone_type,
  884.                     (const gx_device *)cdev);
  885.                   }
  886.                 continue;
  887.             case cmd_opv_end_page:
  888.                  if_debug0('L', "\n");
  889.                  /*
  890.                   * Do end-of-page cleanup, then reinitialize if
  891.                   * there are more pages to come.
  892.                   */
  893.                  goto out;
  894.             case cmd_opv_delta2_color0:
  895.                  pcolor = &set_colors[0];
  896.                  goto delta2_c;
  897.             case cmd_opv_delta2_color1:
  898.                  pcolor = &set_colors[1];
  899. delta2_c:             set_colors = state.colors;
  900.                  { gx_color_index b = ((uint)*cbp << 8) + cbp[1];
  901.                    cbp += 2;
  902.                    if ( dev_depth > 24 )
  903.                  *pcolor +=
  904.                    ((b & 0xf000) << 12) + ((b & 0x0f00) << 8) +
  905.                      ((b & 0x00f0) << 4) + (b & 0x000f) -
  906.                        cmd_delta2_32_bias;
  907.                    else
  908.                  *pcolor +=
  909.                    ((b & 0xf800) << 5) + ((b & 0x07e0) << 3) +
  910.                      (b & 0x001f) - cmd_delta2_24_bias;
  911.                  }
  912.                  if_debug1('L', " 0x%lx\n", *pcolor);
  913.                  continue;
  914.             case cmd_opv_set_copy_color:
  915.                  state.color_is_alpha = 0;
  916.                  if_debug0('L', "\n");
  917.                  continue;
  918.             case cmd_opv_set_copy_alpha:
  919.                  state.color_is_alpha = 1;
  920.                  if_debug0('L', "\n");
  921.                  continue;
  922.             default:
  923.                  goto bad_op;
  924.                }
  925.             /*NOTREACHED*/
  926.         case cmd_op_set_color0 >> 4:
  927.             pcolor = &set_colors[0];
  928.             goto set_color;
  929.         case cmd_op_set_color1 >> 4:
  930.             pcolor = &set_colors[1];
  931. set_color:        set_colors = state.colors;
  932.             switch ( op & 0xf )
  933.              {
  934.              case 0:
  935.                break;
  936.              case 15:    /* special handling because this may */
  937.                     /* require more bits than depth */
  938.                *pcolor = gx_no_color_index;
  939.                goto setc;
  940.              default:
  941.                switch ( dev_depth_bytes )
  942.                  {
  943.                  case 4:
  944.                    { gx_color_index b =
  945.                    ((gx_color_index)(op & 0xf) << 8) + *cbp++;
  946.                  *pcolor +=
  947.                    ((b & 07000) << 15) + ((b & 0700) << 10) +
  948.                      ((b & 070) << 5) + (b & 7) -
  949.                        cmd_delta1_32_bias;
  950.                  goto setc;
  951.                    }
  952.                  case 3:
  953.                    { gx_color_index b = *cbp++;
  954.                  *pcolor +=
  955.                    ((gx_color_index)(op & 0xf) << 16) +
  956.                      ((b & 0xf0) << 4) + (b & 0x0f) -
  957.                        cmd_delta1_24_bias;
  958.                  goto setc;
  959.                    }
  960.                  case 2:
  961.                    break;
  962.                  case 1:
  963.                    *pcolor += (gx_color_index)(op & 0xf) - 8;
  964.                    goto setc;
  965.                  }
  966.              }
  967.             { gx_color_index color = 0;
  968.               switch ( dev_depth_bytes )
  969.                 {
  970.                 case 4: color |= (gx_color_index)*cbp++ << 24;
  971.                 case 3: color |= (gx_color_index)*cbp++ << 16;
  972.                 case 2: color |= (gx_color_index)*cbp++ << 8;
  973.                 case 1: color |= (gx_color_index)*cbp++;
  974.                 }
  975.               *pcolor = color;
  976.             }
  977. setc:            if_debug1('L', " 0x%lx\n", *pcolor);
  978.             continue;
  979.         case cmd_op_fill_rect >> 4:
  980.         case cmd_op_tile_rect >> 4:
  981.             cbp = cmd_read_rect(op, &state.rect, cbp);
  982.             break;
  983.         case cmd_op_fill_rect_short >> 4:
  984.         case cmd_op_tile_rect_short >> 4:
  985.             state.rect.x += *cbp + cmd_min_short;
  986.             state.rect.width += cbp[1] + cmd_min_short;
  987.             if ( op & 0xf )
  988.               { state.rect.height += (op & 0xf) + cmd_min_dxy_tiny;
  989.                 cbp += 2;
  990.               }
  991.             else
  992.               { state.rect.y += cbp[2] + cmd_min_short;
  993.                 state.rect.height += cbp[3] + cmd_min_short;
  994.                 cbp += 4;
  995.               }
  996.             break;
  997.         case cmd_op_fill_rect_tiny >> 4:
  998.         case cmd_op_tile_rect_tiny >> 4:
  999.             if ( op & 8 )
  1000.               state.rect.x += state.rect.width;
  1001.             else
  1002.               { int txy = *cbp++;
  1003.                 state.rect.x += (txy >> 4) + cmd_min_dxy_tiny;
  1004.                 state.rect.y += (txy & 0xf) + cmd_min_dxy_tiny;
  1005.               }
  1006.             state.rect.width += (op & 7) + cmd_min_dw_tiny;
  1007.             break;
  1008.         case cmd_op_copy_mono >> 4:
  1009.             depth = 1;
  1010.             goto copy;
  1011.         case cmd_op_copy_color_alpha >> 4:
  1012.             if ( state.color_is_alpha )
  1013.               { if ( !(op & 8) )
  1014.                   depth = *cbp++;
  1015.               }
  1016.             else
  1017.               depth = dev_depth;
  1018. copy:            cmd_getw(state.rect.x, cbp);
  1019.             cmd_getw(state.rect.y, cbp);
  1020.             if ( op & 8 )
  1021.               {    /* Use the current "tile". */
  1022. #ifdef DEBUG
  1023.                 if ( state_slot->index != state.tile_index )
  1024.                   { lprintf2("state_slot->index = %d, state.tile_index = %d!\n",
  1025.                          state_slot->index,
  1026.                          state.tile_index);
  1027.                     code = gs_note_error(gs_error_ioerror);
  1028.                     goto out;
  1029.                   }
  1030. #endif
  1031.                 depth = state_slot->cb_depth;
  1032.                 state.rect.width = state_slot->width;
  1033.                 state.rect.height = state_slot->height;
  1034.                 raster = state_slot->cb_raster;
  1035.                 source = (byte *)(state_slot + 1);
  1036.               }
  1037.             else
  1038.               {    /* Read width, height, bits. */
  1039.                 /* depth was set already. */
  1040.                 uint width_bits, width_bytes;
  1041.                 uint bytes;
  1042.  
  1043.                 cmd_getw(state.rect.width, cbp);
  1044.                 cmd_getw(state.rect.height, cbp);
  1045.                 width_bits = state.rect.width * depth;
  1046.                 bytes =
  1047.                   clist_bitmap_bytes(width_bits,
  1048.                              state.rect.height,
  1049.                              op & 3, &width_bytes,
  1050.                              (uint *)&raster);
  1051.             /* copy_mono and copy_color/alpha */
  1052.             /* ensure that the bits will fit in a single buffer, */
  1053.             /* even after decompression if compressed. */
  1054. #ifdef DEBUG
  1055.                 if ( bytes > cbuf_size )
  1056.                   {    lprintf6("bitmap size exceeds buffer!  width=%d raster=%d height=%d\n    file pos %ld buf pos %d/%d\n",
  1057.                          state.rect.width, raster,
  1058.                          state.rect.height,
  1059.                          stell(s), (int)(cbp - cbuf),
  1060.                          (int)(cb_end - cbuf));
  1061.                     code = gs_note_error(gs_error_ioerror);
  1062.                     goto out;
  1063.                   }
  1064. #endif
  1065.                 if ( op & 3 )
  1066.                 {    /* Decompress the image data. */
  1067.                 stream_cursor_read r;
  1068.                 stream_cursor_write w;
  1069.                 /* We don't know the data length a priori, */
  1070.                 /* so to be conservative, we read */
  1071.                 /* the uncompressed size. */
  1072.                 uint cleft = cb_end - cbp;
  1073.                 if ( cleft < bytes )
  1074.                   {    uint nread = cbuf_size - cleft;
  1075.                     memmove(cbuf, cbp, cleft);
  1076.                     end_status = sgets(s, cbuf + cleft, nread, &nread);
  1077.                     set_cb_end(cbuf + cleft + nread);
  1078.                     cbp = cbuf;
  1079.                   }
  1080.                 r.ptr = cbp - 1;
  1081.                 r.limit = cb_end - 1;
  1082.                 w.ptr = data_bits - 1;
  1083.                 w.limit = w.ptr + data_bits_size;
  1084.                 switch ( op & 3 )
  1085.                   {
  1086.                   case cmd_compress_rle: 
  1087.                     { stream_RLD_state sstate;
  1088.                       clist_rld_init(&sstate);
  1089.                       /* The process procedure can't fail. */
  1090.                       (*s_RLD_template.process)
  1091.                     ((stream_state *)&sstate, &r, &w, true);
  1092.                     } break;
  1093.                   case cmd_compress_cfe:
  1094.                     { stream_CFD_state sstate;
  1095.                       clist_cfd_init(&sstate,
  1096.                              width_bytes << 3 /*state.rect.width*/,
  1097.                              state.rect.height);
  1098.                       /* The process procedure can't fail. */
  1099.                       (*s_CFD_template.process)
  1100.                     ((stream_state *)&sstate, &r, &w, true);
  1101.                       (*s_CFD_template.release)
  1102.                     ((stream_state *)&sstate);
  1103.                     } break;
  1104.                   default:
  1105.                     goto bad_op;
  1106.                   }
  1107.                 cbp = r.ptr + 1;
  1108.                 source = data_bits;
  1109.                 }
  1110.                 else if ( state.rect.height > 1 &&
  1111.                       width_bytes != raster
  1112.                     )
  1113.                   { source = data_bits;
  1114.                     cmd_read_short_bits(source, width_bytes,
  1115.                             state.rect.height,
  1116.                             raster, cbp);
  1117.                   }
  1118.                 else
  1119.                   { cmd_read(cbuf, bytes, cbp);
  1120.                     source = cbuf;
  1121.                   }
  1122. #ifdef DEBUG
  1123.                 if ( gs_debug_c('L') )
  1124.                   { dprintf2(" depth=%d, data_x=%d\n",
  1125.                          depth, data_x);
  1126.                     cmd_print_bits(source, state.rect.width,
  1127.                            state.rect.height, raster);
  1128.                   }
  1129. #endif
  1130.               }
  1131.             break;
  1132.         case cmd_op_delta_tile_index >> 4:
  1133.             state.tile_index += (int)(op & 0xf) - 8;
  1134.             goto sti;
  1135.         case cmd_op_set_tile_index >> 4:
  1136.             state.tile_index =
  1137.               ((op & 0xf) << 8) + *cbp++;
  1138. sti:            state_slot =
  1139.               (tile_slot *)(cdev->chunk.data +
  1140.                 cdev->tile_table[state.tile_index].offset);
  1141.             if_debug2('L', " index=%u offset=%lu\n",
  1142.                   state.tile_index,
  1143.                   cdev->tile_table[state.tile_index].offset);
  1144.             state_tile.data = (byte *)(state_slot + 1);
  1145. stp:            state_tile.size.x = state_slot->width;
  1146.             state_tile.size.y = state_slot->height;
  1147.             state_tile.raster = state_slot->cb_raster;
  1148.             state_tile.rep_width = state_tile.size.x /
  1149.               state_slot->x_reps;
  1150.             state_tile.rep_height = state_tile.size.y /
  1151.               state_slot->y_reps;
  1152.             state_tile.rep_shift = state_slot->rep_shift;
  1153.             state_tile.shift = state_slot->shift;
  1154. set_phase:        tile_phase.x =
  1155.               (state.tile_phase.x + x0) % state_tile.size.x;
  1156.             tile_phase.y =
  1157.               (state.tile_phase.y + y0) % state_tile.size.y;
  1158.             gx_imager_setscreenphase(&imager_state,
  1159.                          -(state.tile_phase.x + x0),
  1160.                          -(state.tile_phase.y + y0),
  1161.                          gs_color_select_all);
  1162.             continue;
  1163.         case cmd_op_misc2 >> 4:
  1164.             switch ( op )
  1165.                {
  1166.             case cmd_opv_set_flatness:
  1167.                 cmd_get_value(imager_state.flatness, cbp);
  1168.                 if_debug1('L', " %g\n", imager_state.flatness);
  1169.                 continue;
  1170.             case cmd_opv_set_fill_adjust:
  1171.                 cmd_get_value(imager_state.fill_adjust.x, cbp);
  1172.                 cmd_get_value(imager_state.fill_adjust.y, cbp);
  1173.                 if_debug2('L', " (%g,%g)\n",
  1174.                       fixed2float(imager_state.fill_adjust.x),
  1175.                       fixed2float(imager_state.fill_adjust.y));
  1176.                 continue;
  1177.             case cmd_opv_set_ctm:
  1178.                 { gs_matrix mat;
  1179.                   cbp = cmd_read_matrix(&mat, cbp);
  1180.                   mat.tx -= x0;
  1181.                   mat.ty -= y0;
  1182.                   gs_imager_setmatrix(&imager_state, &mat);
  1183.                   if_debug6('L', " [%g %g %g %g %g %g]\n",
  1184.                         mat.xx, mat.xy, mat.yx, mat.yy,
  1185.                         mat.tx, mat.ty);
  1186.                 }
  1187.                 continue;
  1188.             case cmd_opv_set_line_width:
  1189.                 { float width;
  1190.                   cmd_get_value(width, cbp);
  1191.                   if_debug1('L', " %g\n", width);
  1192.                   gx_set_line_width(&imager_state.line_params, width);
  1193.                 }
  1194.                 continue;
  1195.             case cmd_opv_set_misc2:
  1196.               {    uint cb = *cbp;
  1197.                 switch ( cb >> 6 )
  1198.                   {
  1199.                   case cmd_set_misc2_cap_join >> 6:
  1200.                     imager_state.line_params.cap =
  1201.                       (gs_line_cap)((cb >> 3) & 7);
  1202.                     imager_state.line_params.join =
  1203.                       (gs_line_join)(cb & 7);
  1204.                     if_debug2('L', " cap=%d join=%d\n",
  1205.                           imager_state.line_params.cap,
  1206.                           imager_state.line_params.join);
  1207.                     break;
  1208.                   case cmd_set_misc2_ac_op_sa >> 6:
  1209.                     imager_state.accurate_curves =
  1210.                       (cb & 4) != 0;
  1211.                     imager_state.overprint = (cb & 2) != 0;
  1212.                     imager_state.stroke_adjust = cb & 1;
  1213.                     if_debug3('L', " AC=%d OP=%d SA=%d\n",
  1214.                           imager_state.accurate_curves,
  1215.                           imager_state.overprint,
  1216.                           imager_state.stroke_adjust);
  1217.                     break;
  1218.                   case cmd_set_misc2_notes >> 6:
  1219.                     notes = (segment_notes)(cb & 0x3f);
  1220.                     if_debug1('L', " notes=%d\n", notes);
  1221.                     break;
  1222.                   default:
  1223.                     goto bad_op;
  1224.                   }
  1225.               }
  1226.                 cbp++;
  1227.                 continue;
  1228.             case cmd_opv_set_miter_limit:
  1229.                 { float limit;
  1230.                   cmd_get_value(limit, cbp);
  1231.                   if_debug1('L', " %g\n", limit);
  1232.                   gx_set_miter_limit(&imager_state.line_params, limit);
  1233.                 }
  1234.                 continue;
  1235.             case cmd_opv_set_dash:
  1236.                 { int nb = *cbp++;
  1237.                   int n = nb & 0x3f;
  1238.                   float dot_length, offset;
  1239.  
  1240.                   cmd_get_value(dot_length, cbp);
  1241.                   cmd_get_value(offset, cbp);
  1242.                   memcpy(dash_pattern, cbp, n * sizeof(float));
  1243.                   gx_set_dash(&imager_state.line_params.dash,
  1244.                           dash_pattern, n, offset,
  1245.                           NULL);
  1246.                   gx_set_dash_adapt(&imager_state.line_params.dash,
  1247.                             (nb & 0x80) != 0);
  1248.                   gx_set_dot_length(&imager_state.line_params,
  1249.                             dot_length,
  1250.                             (nb & 0x40) != 0);
  1251. #ifdef DEBUG
  1252.                   if ( gs_debug_c('L') )
  1253.                     { int i;
  1254.                       dprintf4(" dot=%g(mode %d) adapt=%d offset=%g [",
  1255.                            dot_length,
  1256.                            (nb & 0x40) != 0,
  1257.                            (nb & 0x80) != 0, offset);
  1258.                       for ( i = 0; i < n; ++i )
  1259.                     dprintf1("%g ", dash_pattern[i]);
  1260.                       dputs("]\n");
  1261.                     }
  1262. #endif
  1263.                   cbp += n * sizeof(float);
  1264.                 }
  1265.                 break;
  1266.             case cmd_opv_enable_clip:
  1267.                 pcpath = (use_clip ? &clip_path : NULL);
  1268.                 if_debug0('L', "\n");
  1269.                 break;
  1270.             case cmd_opv_disable_clip:
  1271.                 pcpath = NULL;
  1272.                 if_debug0('L', "\n");
  1273.                 break;
  1274.             case cmd_opv_begin_clip:
  1275.                 pcpath = NULL;
  1276.                 if_debug0('L', "\n");
  1277.                 gx_cpath_release(&clip_path);
  1278.                 gx_cpath_accum_begin(&clip_accum, mem);
  1279.                 gx_cpath_accum_set_cbox(&clip_accum,
  1280.                             &target_box);
  1281.                 tdev = (gx_device *)&clip_accum;
  1282.                 clip_save.lop_enabled = state.lop_enabled;
  1283.                 clip_save.fill_adjust =
  1284.                   imager_state.fill_adjust;
  1285.                 state.lop_enabled = false;
  1286.                 imager_state.log_op = lop_default;
  1287.                 imager_state.fill_adjust.x =
  1288.                   imager_state.fill_adjust.y = fixed_half;
  1289.                 break;
  1290.             case cmd_opv_end_clip:
  1291.                 if_debug0('L', "\n");
  1292.                 gx_cpath_accum_end(&clip_accum, &clip_path);
  1293.                 gx_cpath_set_outside(&clip_path, *cbp++);
  1294.                 tdev = target;
  1295.                 /*
  1296.                  * If the entire band falls within the clip
  1297.                  * path, no clipping is needed.
  1298.                  */
  1299.                 { gs_fixed_rect cbox;
  1300.  
  1301.                   gx_cpath_inner_box(&clip_path, &cbox);
  1302.                   use_clip =
  1303.                     !(cbox.p.x <= target_box.p.x &&
  1304.                       cbox.q.x >= target_box.q.x &&
  1305.                       cbox.p.y <= target_box.p.y &&
  1306.                       cbox.q.y >= target_box.q.y);
  1307.                 }
  1308.                 pcpath = (use_clip ? &clip_path : NULL);
  1309.                 state.lop_enabled = clip_save.lop_enabled;
  1310.                 imager_state.log_op =
  1311.                   (state.lop_enabled ? state.lop :
  1312.                    lop_default);
  1313.                 imager_state.fill_adjust =
  1314.                   clip_save.fill_adjust;
  1315.                 break;
  1316.             case cmd_opv_set_color_space:
  1317.                 { byte b = *cbp++;
  1318.                   int index = b >> 4;
  1319.  
  1320.                   if_debug2('L', " %d%s\n", index,
  1321.                         (b & 8? " (indexed)" : ""));
  1322.                   switch ( index )
  1323.                     {
  1324.                     case gs_color_space_index_DeviceGray:
  1325.                       pcs = gs_color_space_DeviceGray();
  1326.                       break;
  1327.                     case gs_color_space_index_DeviceRGB:
  1328.                       pcs = gs_color_space_DeviceRGB();
  1329.                       break;
  1330.                     case gs_color_space_index_DeviceCMYK:
  1331.                       pcs = gs_color_space_DeviceCMYK();
  1332.                       break;
  1333.                     default:
  1334.                       goto bad_op; /* others are NYI */
  1335.                     }
  1336.                   if ( b & 8 )
  1337.                     { int num_comp =
  1338.                     gs_color_space_num_components(pcs);
  1339.  
  1340.                       color_space.type = &gs_color_space_type_Indexed;
  1341.                       color_space.params.indexed.base_space.type = pcs->type;
  1342.                       cmd_getw(color_space.params.indexed.hival,
  1343.                            cbp);
  1344.                       color_space.params.indexed.use_proc =
  1345.                     (b & 4) != 0;
  1346.                       /****** SET map ******/
  1347.                       pcs = &color_space;
  1348.                     }
  1349.                 }
  1350.                 break;
  1351.             case cmd_opv_begin_image:
  1352.                 { byte b = *cbp++;
  1353.                   int bpci = b >> 5;
  1354.                   static const byte bpc[6] =
  1355.                     {1, 1, 2, 4, 8, 12};
  1356.                   gx_drawing_color devc;
  1357.                   int num_components;
  1358.                   gs_image_format_t format;
  1359.  
  1360. #ifdef FUTURE
  1361.                   if ( b & (1 << 4) )
  1362.                     { byte b2 = *cbp++;
  1363.                       format = b2 >> 6;
  1364.                       image.Interpolate = (b2 & (1 << 5)) != 0;
  1365.                     }
  1366.                   else
  1367.                     { format = gs_image_format_chunky;
  1368.                       image.Interpolate = false;
  1369.                     }
  1370. #else
  1371.                   format = gs_image_format_chunky;
  1372.                   image.Interpolate = (b & (1 << 4)) != 0;
  1373. #endif
  1374.                   cmd_getw(image.Width, cbp);
  1375.                   cmd_getw(image.Height, cbp);
  1376.                   if_debug4('L', " BPCi=%d I=%d size=(%d,%d)",
  1377.                         bpci, (b & 0x10) != 0,
  1378.                         image.Width, image.Height);
  1379.                   if ( b & (1 << 3) )
  1380.                     { /* Non-standard ImageMatrix */
  1381.                       cbp = cmd_read_matrix(
  1382.                     &image.ImageMatrix, cbp);
  1383.                       if_debug6('L', " matrix=[%g %g %g %g %g %g]",
  1384.                         image.ImageMatrix.xx,
  1385.                         image.ImageMatrix.xy,
  1386.                         image.ImageMatrix.yx,
  1387.                         image.ImageMatrix.yy,
  1388.                         image.ImageMatrix.tx,
  1389.                         image.ImageMatrix.ty);
  1390.                     }
  1391.                   else
  1392.                     { image.ImageMatrix.xx = image.Width;
  1393.                       image.ImageMatrix.xy = 0;
  1394.                       image.ImageMatrix.yx = 0;
  1395.                       image.ImageMatrix.yy = -image.Height;
  1396.                       image.ImageMatrix.tx = 0;
  1397.                       image.ImageMatrix.ty = image.Height;
  1398.                     }
  1399.                   image.BitsPerComponent = bpc[bpci];
  1400.                   if ( bpci == 0 )
  1401.                     { image.ColorSpace = 0;
  1402.                       image.ImageMask = true;
  1403.                       image.Decode[0] = 0;
  1404.                       image.Decode[1] = 1;
  1405.                       num_components = 1;
  1406.                     }
  1407.                   else
  1408.                     { image.ColorSpace = pcs;
  1409.                       image.ImageMask = false;
  1410.                       if ( gs_color_space_get_index(pcs) == gs_color_space_index_Indexed )
  1411.                     { image.Decode[0] = 0;
  1412.                       image.Decode[1] =
  1413.                         (1 << image.BitsPerComponent) - 1;
  1414.                     }
  1415.                       else
  1416.                     { static const float decode01[] =
  1417.                         { 0, 1, 0, 1, 0, 1, 0, 1
  1418. #ifdef DPNEXT
  1419.                           , 0, 1
  1420. #endif
  1421.                         };
  1422.                       memcpy(image.Decode, decode01,
  1423.                          sizeof(image.Decode));
  1424.                     }
  1425.                       num_components =
  1426.                     gs_color_space_num_components(pcs);
  1427.                     }
  1428. #ifdef FUTURE
  1429.                   switch ( format )
  1430.                     {
  1431.                     case gs_image_format_chunky:
  1432.                       image_num_planes = 1; break;
  1433.                     case gs_image_format_component_planar:
  1434.                       image_num_planes = num_components; break;
  1435.                     case gs_image_format_bit_planar:
  1436.                       image_num_planes = num_components *
  1437.                     image.BitsPerComponent; break;
  1438.                     default:
  1439.                       goto bad_op;
  1440.                     }
  1441. #else
  1442.                   image_num_planes = 1;
  1443. #endif
  1444.                   if ( b & (1 << 2) )
  1445.                     { /* Non-standard Decode */
  1446.                       byte dflags = *cbp++;
  1447.                       int i;
  1448.  
  1449.                       for ( i = 0; i < num_components * 2;
  1450.                         dflags <<= 2, i += 2
  1451.                       )
  1452.                     switch ( (dflags >> 6) & 3 )
  1453.                       {
  1454.                       case 0:    /* default */
  1455.                         break;
  1456.                       case 1:    /* swapped default */
  1457.                         image.Decode[i] =
  1458.                           image.Decode[i+1];
  1459.                         image.Decode[i+1] = 0;
  1460.                         break;
  1461.                       case 3:
  1462.                         cmd_get_value(image.Decode[i],
  1463.                               cbp);
  1464.                         /* falls through */
  1465.                       case 2:
  1466.                         cmd_get_value(image.Decode[i+1],
  1467.                               cbp);
  1468.                       }
  1469. #ifdef DEBUG
  1470.                       if ( gs_debug_c('L') )
  1471.                     { dputs(" decode=[");
  1472.                       for ( i = 0; i < num_components * 2;
  1473.                         ++i
  1474.                           )
  1475.                         dprintf1("%g ", image.Decode[i]);
  1476.                       dputc(']');
  1477.                     }
  1478. #endif
  1479.                     }
  1480.                   image.adjust = false;
  1481.                   image.CombineWithColor = false;
  1482. #ifdef DPNEXT
  1483.                   image.HasAlpha = false;
  1484. #endif
  1485.                   if ( b & (1 << 1) )
  1486.                     { if ( image.ImageMask )
  1487.                     image.adjust = true;
  1488.                       else
  1489.                     image.CombineWithColor = true;
  1490.                       if_debug1('L', " %s",
  1491.                         (image.ImageMask ? " adjust" :
  1492.                          " CWC"));
  1493.                     }
  1494.                   if ( b & (1 << 0) )
  1495.                     { /* Non-standard rectangle */
  1496.                       uint diff;
  1497.                       cmd_getw(image_rect.p.x, cbp);
  1498.                       cmd_getw(image_rect.p.y, cbp);
  1499.                       cmd_getw(diff, cbp);
  1500.                       image_rect.q.x = image.Width - diff;
  1501.                       cmd_getw(diff, cbp);
  1502.                       image_rect.q.y = image.Height - diff;
  1503.                       if_debug4('L', " rect=(%d,%d),(%d,%d)",
  1504.                         image_rect.p.x, image_rect.p.y,
  1505.                         image_rect.q.x, image_rect.q.y);
  1506.                     }
  1507.                   else
  1508.                     { image_rect.p.x = 0;
  1509.                       image_rect.p.y = 0;
  1510.                       image_rect.q.x = image.Width;
  1511.                       image_rect.q.y = image.Height;
  1512.                     }
  1513.                   if_debug0('L', "\n");
  1514.                   color_set_pure(&devc, state.colors[1]);
  1515.                   code = (*dev_proc(tdev, begin_image))
  1516.                     (tdev, &imager_state, &image, format,
  1517.                      &image_rect, &devc, pcpath, mem,
  1518.                      &image_info);
  1519.                   if ( code < 0 )
  1520.                     goto out;
  1521.                 }
  1522.                 break;
  1523.             case cmd_opv_image_data:
  1524.                 { uint height;
  1525.  
  1526.                   cmd_getw(height, cbp);
  1527.                   if ( height == 0 )
  1528.                     { if_debug0('L', " done\n");
  1529.                       code = (*dev_proc(tdev, end_image))
  1530.                     (tdev, image_info, true);
  1531.                     }
  1532.                   else
  1533.                     { uint bytes_per_plane, nbytes;
  1534.                       byte *data;
  1535.                       byte *data_on_heap = 0;
  1536.                       const byte *planes[64];
  1537.                       /****** DOESN'T HANDLE #PLANES YET *****/
  1538.  
  1539.                       cmd_getw(bytes_per_plane, cbp);
  1540.                       if_debug2('L', " height=%u raster=%u\n",
  1541.                         height, bytes_per_plane);
  1542.                       nbytes = bytes_per_plane *
  1543.                     image_num_planes * height;
  1544.                       if ( cb_end - cbp >= nbytes )
  1545.                     { data = cbp;
  1546.                       cbp += nbytes;
  1547.                     }
  1548.                       else
  1549.                     { uint cleft = cb_end - cbp;
  1550.                       uint rleft = nbytes - cleft;
  1551.                       byte *rdata;
  1552.  
  1553.                       if ( nbytes > cb_end - cbuf )
  1554.                         { /* Allocate a separate buffer. */
  1555.                           rdata = data_on_heap =
  1556.                         gs_alloc_bytes(mem, nbytes,
  1557.                             "clist image_data");
  1558.                           if ( rdata == 0 )
  1559.                         { code = gs_note_error(gs_error_VMerror);
  1560.                           goto out;
  1561.                         }
  1562.                         }
  1563.                       else
  1564.                         rdata = cbuf;
  1565.                       memmove(rdata, cbp, cleft);
  1566.                       sgets(s, rdata + cleft, rleft,
  1567.                         &rleft);
  1568.                       data = rdata;
  1569.                       cbp = cb_end;  /* force refill */
  1570.                     }
  1571. #ifdef DEBUG
  1572.                       if ( gs_debug_c('L') )
  1573.                     cmd_print_bits(data, image_rect.q.x -
  1574.                                image_rect.p.x,
  1575.                                image_num_planes * height,
  1576.                                bytes_per_plane);
  1577. #endif
  1578. #ifdef FUTURE
  1579.                       { int plane;
  1580.                         for ( plane = 0;
  1581.                           plane < image_num_planes;
  1582.                           ++plane
  1583.                         )
  1584.                       planes[plane] = data +
  1585.                         bytes_per_plane * height * plane;
  1586.                       }
  1587. #else
  1588.                       planes[0] = data;
  1589. #endif
  1590.                       code = (*dev_proc(tdev, image_data))
  1591.                     (tdev, image_info, planes, data_x,
  1592.                      bytes_per_plane, height);
  1593.                       if ( data_on_heap )
  1594.                     gs_free_object(mem, data_on_heap,
  1595.                                "clist image_data");
  1596.                       data_x = 0;
  1597.                     }
  1598.                 }
  1599.                 if ( code < 0 )
  1600.                   goto out;
  1601.                 continue;
  1602.             case cmd_opv_set_color:
  1603.                 {
  1604. #define dcb dev_color.colors.colored.c_base
  1605. #define dcl dev_color.colors.colored.c_level
  1606.                 byte b = *cbp++;
  1607.                 int i;
  1608.  
  1609.                 switch ( b >> 4 )
  1610.                   {
  1611.                   case 0:
  1612.                     dcb[0] = (b >> 3) & 1;
  1613.                     dcb[1] = (b >> 2) & 1;
  1614.                     dcb[2] = (b >> 1) & 1;
  1615.                     dcb[3] = b & 1;
  1616.                     break;
  1617.                   case 1:
  1618.                     dcb[0] = ((b & 0xf) << 1) + (*cbp >> 7);
  1619.                     dcb[1] = (*cbp >> 2) & 0x1f;
  1620.                     dcb[2] = ((*cbp & 3) << 3) + (cbp[1] >> 5);
  1621.                     dcb[3] = cbp[1] & 0x1f;
  1622.                     cbp += 2;
  1623.                     break;
  1624.                   default:
  1625.                     goto bad_op;
  1626.                   }
  1627.                 for ( i = 0; i < imager_state.dev_ht->num_comp; ++i )
  1628.                   cmd_getw(dcl[i], cbp);
  1629.                 if_debug10('L', " format %d num_comp=%d base=(%u,%u,%u,%u) level=(%u,%u,%u,%u)\n",
  1630.                        b >> 4,
  1631.                        imager_state.dev_ht->num_comp,
  1632.                        dcb[0], dcb[1], dcb[2], dcb[3],
  1633.                        dcl[0], dcl[1], dcl[2], dcl[3]);
  1634.                 color_finish_set_cmyk_halftone(&dev_color,
  1635.                         imager_state.dev_ht);
  1636. #undef dcb
  1637. #undef dcl
  1638.                 }
  1639.                 continue;
  1640.             default:
  1641.                 goto bad_op;
  1642.                }
  1643.             continue;
  1644.         case cmd_op_segment >> 4:
  1645.           {    fixed vs[6];
  1646.             int i, code;
  1647.  
  1648.             if ( !in_path )
  1649.               { ppos.x = int2fixed(state.rect.x);
  1650.                 ppos.y = int2fixed(state.rect.y);
  1651.                 if_debug2('L', " (%d,%d)", state.rect.x,
  1652.                       state.rect.y);
  1653.                 notes = sn_none;
  1654.                 in_path = true;
  1655.               }
  1656.             for ( i = 0;
  1657.                   i < clist_segment_op_num_operands[op & 0xf];
  1658.                   ++i
  1659.                 )
  1660.               { fixed v;
  1661.                 int b = *cbp;
  1662.                 switch ( b >> 5 )
  1663.                   {
  1664.                   case 0: case 1:
  1665.                 vs[i++] =
  1666.                   ((fixed)((b ^ 0x20) - 0x20) << 13) +
  1667.                     ((int)cbp[1] << 5) + (cbp[2] >> 3);
  1668.                 if_debug1('L', " %g", fixed2float(vs[i - 1]));
  1669.                 cbp += 2;
  1670.                 v = (int)((*cbp & 7) ^ 4) - 4;
  1671.                 break;
  1672.                   case 2: case 3:
  1673.                 v = (b ^ 0x60) - 0x20;
  1674.                 break;
  1675.                   case 4: case 5:
  1676.                                 /*
  1677.                  * Without the following cast, C's
  1678.                  * brain-damaged coercion rules cause the
  1679.                  * result to be considered unsigned, and not
  1680.                  * sign-extended on machines where
  1681.                  * sizeof(long) > sizeof(int).
  1682.                  */
  1683.                                 v = (((b ^ 0xa0) - 0x20) << 8) + (int)*++cbp;
  1684.                 break;
  1685.                   case 6:
  1686.                 v = (b ^ 0xd0) - 0x10;
  1687.                 vs[i] =
  1688.                   ((v << 8) + cbp[1]) << (_fixed_shift - 2);
  1689.                 if_debug1('L', " %g", fixed2float(vs[i]));
  1690.                 cbp += 2;
  1691.                 continue;
  1692.                   default /*case 7*/:
  1693.                 v = (int)(*++cbp ^ 0x80) - 0x80;
  1694.                 for ( b = 0; b < sizeof(fixed) - 3; ++b )
  1695.                   v = (v << 8) + *++cbp;
  1696.                 break;
  1697.                   }
  1698.                 cbp += 3;
  1699.                 /* Absent the cast in the next statement, */
  1700.                 /* the Borland C++ 4.5 compiler incorrectly */
  1701.                 /* sign-extends the result of the shift. */
  1702.                 vs[i] = (v << 16) + (uint)(cbp[-2] << 8) + cbp[-1];
  1703.                 if_debug1('L', " %g", fixed2float(vs[i]));
  1704.               }
  1705.             if_debug0('L', "\n");
  1706.             code = clist_decode_segment(&path, op, vs, &ppos,
  1707.                             x0, y0, notes);
  1708.             if ( code < 0 )
  1709.               goto out;
  1710.           }    continue;
  1711.         case cmd_op_path >> 4:
  1712.           {    gx_device_color devc;
  1713.             gx_device_color *pdevc;
  1714.             gx_ht_tile ht_tile;
  1715.  
  1716.             if_debug0('L', "\n");
  1717.             switch ( op )
  1718.               {
  1719.               case cmd_opv_fill:
  1720.                 fill_params.rule = gx_rule_winding_number;
  1721.                 goto fill_pure;
  1722.               case cmd_opv_eofill:
  1723.                 fill_params.rule = gx_rule_even_odd;
  1724. fill_pure:            color_set_pure(&devc, state.colors[1]);
  1725.                 pdevc = &devc;
  1726.                 goto fill;
  1727.               case cmd_opv_htfill:
  1728.                 fill_params.rule = gx_rule_winding_number;
  1729.                 goto fill_ht;
  1730.               case cmd_opv_hteofill:
  1731.                 fill_params.rule = gx_rule_even_odd;
  1732. fill_ht:            ht_tile.tiles = state_tile;
  1733.                 color_set_binary_tile(&devc,
  1734.                               state.tile_colors[0],
  1735.                               state.tile_colors[1],
  1736.                               &ht_tile);
  1737.                 pdevc = &devc;
  1738.                 pdevc->phase = tile_phase;
  1739.                 goto fill;
  1740.               case cmd_opv_colorfill:
  1741.                 fill_params.rule = gx_rule_winding_number;
  1742.                 goto fill_color;
  1743.               case cmd_opv_coloreofill:
  1744.                 fill_params.rule = gx_rule_even_odd;
  1745. fill_color:            pdevc = &dev_color;
  1746.                 pdevc->phase = tile_phase;
  1747.                 code =
  1748.                   gx_color_load(pdevc, &imager_state, tdev);
  1749.                 if ( code < 0 )
  1750.                   break;
  1751. fill:                fill_params.adjust = imager_state.fill_adjust;
  1752.                 fill_params.flatness = imager_state.flatness;
  1753.                 code = gx_fill_path_only(&path, tdev,
  1754.                              &imager_state,
  1755.                              &fill_params,
  1756.                              pdevc, pcpath);
  1757.                 break;
  1758.               case cmd_opv_stroke:
  1759.                 color_set_pure(&devc, state.colors[1]);
  1760.                 pdevc = &devc;
  1761.                 goto stroke;
  1762.               case cmd_opv_htstroke:
  1763.                 ht_tile.tiles = state_tile;
  1764.                 color_set_binary_tile(&devc,
  1765.                               state.tile_colors[0],
  1766.                               state.tile_colors[1],
  1767.                               &ht_tile);
  1768.                 pdevc = &devc;
  1769.                 pdevc->phase = tile_phase;
  1770.                 goto stroke;
  1771.               case cmd_opv_colorstroke:
  1772.                 pdevc = &dev_color;
  1773.                 pdevc->phase = tile_phase;
  1774.                 code =
  1775.                   gx_color_load(pdevc, &imager_state, tdev);
  1776.                 if ( code < 0 )
  1777.                   break;
  1778. stroke:                stroke_params.flatness = imager_state.flatness;
  1779.                 code = gx_stroke_path_only(&path,
  1780.                         (gx_path *)0, tdev,
  1781.                         &imager_state, &stroke_params,
  1782.                         pdevc, pcpath);
  1783.                 break;
  1784.               default:
  1785.                 goto bad_op;
  1786.               }
  1787.           }
  1788.             if ( in_path ) /* path might be empty! */
  1789.               { state.rect.x = fixed2int_var(ppos.x);
  1790.                 state.rect.y = fixed2int_var(ppos.y);
  1791.                 in_path = false;
  1792.               }
  1793.             gx_path_release(&path);
  1794.             gx_path_init(&path, mem);
  1795.             if ( code < 0 )
  1796.               goto out;
  1797.             continue;
  1798.         default:
  1799. bad_op:            lprintf5("Bad op %02x band y0 = %d file pos %ld buf pos %d/%d\n",
  1800.                  op, y0, stell(s), (int)(cbp - cbuf), (int)(cb_end - cbuf));
  1801.                {    const byte *pp;
  1802.                 for ( pp = cbuf; pp < cb_end; pp += 10 )
  1803.                   { dprintf1("%4d:", (int)(pp - cbuf));
  1804.                     dprintf10(" %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x\n",
  1805.                     pp[0], pp[1], pp[2], pp[3], pp[4],
  1806.                     pp[5], pp[6], pp[7], pp[8], pp[9]);
  1807.                   }
  1808.                }
  1809.             code = gs_note_error(gs_error_Fatal);
  1810.             goto out;
  1811.            }
  1812.         if_debug4('L', " x=%d y=%d w=%d h=%d\n",
  1813.               state.rect.x, state.rect.y, state.rect.width,
  1814.               state.rect.height);
  1815.         switch ( op >> 4 )
  1816.            {
  1817.         case cmd_op_fill_rect >> 4:
  1818.         case cmd_op_fill_rect_short >> 4:
  1819.         case cmd_op_fill_rect_tiny >> 4:
  1820.             if ( !state.lop_enabled )
  1821.               { code = (*dev_proc(tdev, fill_rectangle))
  1822.                   (tdev, state.rect.x - x0, state.rect.y - y0,
  1823.                    state.rect.width, state.rect.height,
  1824.                    state.colors[1]);
  1825.                 break;
  1826.               }
  1827.             source = NULL;
  1828.             data_x = 0;
  1829.             raster = 0;
  1830.             colors[0] = colors[1] = state.colors[1];
  1831.             log_op = state.lop;
  1832.             pcolor = colors;
  1833. do_rop:            code = (*dev_proc(tdev, strip_copy_rop))
  1834.               (tdev, source, data_x, raster, gx_no_bitmap_id,
  1835.                pcolor, &state_tile,
  1836.                (state.tile_colors[0] == gx_no_color_index &&
  1837.                 state.tile_colors[1] == gx_no_color_index ?
  1838.                 NULL : state.tile_colors),
  1839.                state.rect.x - x0, state.rect.y - y0,
  1840.                state.rect.width - data_x, state.rect.height,
  1841.                tile_phase.x, tile_phase.y, log_op);
  1842.             data_x = 0;
  1843.             break;
  1844.         case cmd_op_tile_rect >> 4:
  1845.         case cmd_op_tile_rect_short >> 4:
  1846.         case cmd_op_tile_rect_tiny >> 4:
  1847.             /* Currently we don't use lop with tile_rectangle. */
  1848.             code = (*dev_proc(tdev, strip_tile_rectangle))
  1849.               (tdev, &state_tile,
  1850.                state.rect.x - x0, state.rect.y - y0,
  1851.                state.rect.width, state.rect.height,
  1852.                state.tile_colors[0], state.tile_colors[1],
  1853.                tile_phase.x, tile_phase.y);
  1854.             break;
  1855.         case cmd_op_copy_mono >> 4:
  1856.             if ( state.lop_enabled )
  1857.               { pcolor = state.colors;
  1858.                 log_op = state.lop;
  1859.                 goto do_rop;
  1860.               }
  1861.             if ( (op & cmd_copy_ht_color) || pcpath != NULL )
  1862.               { /*
  1863.                  * This call of copy_mono originated as a call
  1864.                  * of fill_mask.
  1865.                  */
  1866.                 gx_drawing_color dcolor;
  1867.                 gx_ht_tile ht_tile;
  1868.                 if ( op & cmd_copy_ht_color )
  1869.                   { /* Screwy C assignment rules don't allow: */
  1870.                 /* dcolor.colors = state.tile_colors; */
  1871.                 ht_tile.tiles = state_tile;
  1872.                 color_set_binary_tile(&dcolor,
  1873.                     state.tile_colors[0],
  1874.                     state.tile_colors[1], &ht_tile);
  1875.                 dcolor.phase = tile_phase;
  1876.                   }
  1877.                 else
  1878.                   { color_set_pure(&dcolor, state.colors[1]);
  1879.                   }
  1880.                 code = (*dev_proc(tdev, fill_mask))
  1881.                   (tdev, source, data_x, raster, gx_no_bitmap_id,
  1882.                    state.rect.x - x0, state.rect.y - y0,
  1883.                    state.rect.width - data_x, state.rect.height,
  1884.                    &dcolor, 1, imager_state.log_op, pcpath);
  1885.               }
  1886.             else
  1887.               code = (*dev_proc(tdev, copy_mono))
  1888.                 (tdev, source, data_x, raster, gx_no_bitmap_id,
  1889.                  state.rect.x - x0, state.rect.y - y0,
  1890.                  state.rect.width - data_x, state.rect.height,
  1891.                  state.colors[0], state.colors[1]);
  1892.             data_x = 0;
  1893.             break;
  1894.         case cmd_op_copy_color_alpha >> 4:
  1895.             if ( state.color_is_alpha )
  1896.               { /****** CAN'T DO ROP WITH ALPHA ******/
  1897.                 code = (*dev_proc(tdev, copy_alpha))
  1898.                   (tdev, source, data_x, raster, gx_no_bitmap_id,
  1899.                    state.rect.x - x0, state.rect.y - y0,
  1900.                    state.rect.width - data_x, state.rect.height,
  1901.                    state.colors[1], depth);
  1902.               }
  1903.             else
  1904.               { if ( state.lop_enabled )
  1905.                   { pcolor = NULL;
  1906.                     log_op = state.lop;
  1907.                 goto do_rop;
  1908.                   }
  1909.                 code = (*dev_proc(tdev, copy_color))
  1910.                   (tdev, source, data_x, raster, gx_no_bitmap_id,
  1911.                    state.rect.x - x0, state.rect.y - y0,
  1912.                    state.rect.width - data_x, state.rect.height);
  1913.               }
  1914.             data_x = 0;
  1915.             break;
  1916.         default:        /* can't happen */
  1917.             goto bad_op;
  1918.            }
  1919.        }
  1920.     /* Clean up before we exit. */
  1921. out:    gx_cpath_release(&clip_path);
  1922.     gx_path_release(&path);
  1923.     if ( imager_state.ht_cache )
  1924.       gx_ht_free_cache(mem, imager_state.ht_cache);
  1925.     gx_device_halftone_release(&dev_ht, mem);
  1926.     gs_imager_state_release(&imager_state);
  1927.     gs_free_object(mem, data_bits, "clist_render_band(data_bits)");
  1928.     if ( code < 0 )
  1929.       return_error(code);
  1930.     /* Check whether we have more pages to process. */
  1931.     if ( cbp < cb_end || !seofp(s) )
  1932.       goto in;
  1933.     return code;
  1934. }
  1935.  
  1936. /* Unpack a short bitmap */
  1937. private void
  1938. clist_unpack_short_bits(byte *dest, const byte *src, register int width_bytes,
  1939.   int height, uint raster)
  1940. {    uint bytes = width_bytes * height;
  1941.     const byte *pdata = src + bytes;
  1942.     byte *udata = dest + height * raster;
  1943.     while ( --height >= 0 )
  1944.       {    udata -= raster, pdata -= width_bytes;
  1945.         switch ( width_bytes )
  1946.           {
  1947.           default: memmove(udata, pdata, width_bytes); break;
  1948.           case 6: udata[5] = pdata[5];
  1949.           case 5: udata[4] = pdata[4];
  1950.           case 4: udata[3] = pdata[3];
  1951.           case 3: udata[2] = pdata[2];
  1952.           case 2: udata[1] = pdata[1];
  1953.           case 1: udata[0] = pdata[0];
  1954.           case 0: ;    /* shouldn't happen */
  1955.           }
  1956.       }
  1957. }
  1958.  
  1959. /* Read a rectangle. */
  1960. private const byte *
  1961. cmd_read_rect(int op, register gx_cmd_rect *prect, register const byte *cbp)
  1962. {    cmd_getw(prect->x, cbp);
  1963.     if ( op & 0xf )
  1964.       prect->y += ((op >> 2) & 3) - 2;
  1965.     else
  1966.       { cmd_getw(prect->y, cbp);
  1967.       }
  1968.     cmd_getw(prect->width, cbp);
  1969.     if ( op & 0xf )
  1970.       prect->height += (op & 3) - 2;
  1971.     else
  1972.       { cmd_getw(prect->height, cbp);
  1973.       }
  1974.     return cbp;
  1975. }
  1976.  
  1977. /* Read a transformation matrix. */
  1978. private const byte *
  1979. cmd_read_matrix(gs_matrix *pmat, const byte *cbp)
  1980. {    byte b = *cbp++;
  1981.     float coeff[6];
  1982.     int i;
  1983.  
  1984.     for ( i = 0; i < 4; i += 2, b <<= 2 )
  1985.       if ( !(b & 0xc0) )
  1986.         coeff[i] = coeff[i^3] = 0.0;
  1987.       else
  1988.         { float value;
  1989.           cmd_get_value(value, cbp);
  1990.           coeff[i] = value;
  1991.           switch ( (b >> 6) & 3 )
  1992.         {
  1993.         case 1:
  1994.           coeff[i^3] = value; break;
  1995.         case 2:
  1996.           coeff[i^3] = -value; break;
  1997.         case 3:
  1998.           cmd_get_value(coeff[i^3], cbp);
  1999.         }
  2000.         }
  2001.     for ( ; i < 6; ++i, b <<= 1 )
  2002.       if ( b & 0x80 )
  2003.         { cmd_get_value(coeff[i], cbp);
  2004.         }
  2005.       else
  2006.         coeff[i] = 0.0;
  2007.     pmat->xx = coeff[0];
  2008.     pmat->xy = coeff[1];
  2009.     pmat->yx = coeff[2];
  2010.     pmat->yy = coeff[3];
  2011.     pmat->tx = coeff[4];
  2012.     pmat->ty = coeff[5];
  2013.     return cbp;
  2014. }
  2015.  
  2016. /* Select a map for loading with data. */
  2017. /* load = false is not possible for cmd_map_transfer*. */
  2018. private int
  2019. cmd_select_map(cmd_map_index map_index, bool load, gs_imager_state *pis,
  2020.   gx_ht_order *porder, frac **pmdata, uint *pcount, gs_memory_t *mem)
  2021. {    gx_transfer_map *map;
  2022.     gx_transfer_map **pmap;
  2023.     const char _ds *cname;
  2024.  
  2025.     switch ( map_index )
  2026.       {
  2027.       case cmd_map_transfer:
  2028.         if_debug0('L', " transfer");
  2029.         map = pis->set_transfer.colored.gray;
  2030.         pis->effective_transfer.indexed[0] =
  2031.           pis->effective_transfer.indexed[1] =
  2032.           pis->effective_transfer.indexed[2] =
  2033.           pis->effective_transfer.indexed[3] =
  2034.           map;
  2035.         break;
  2036.       case cmd_map_transfer_0:
  2037.       case cmd_map_transfer_1:
  2038.       case cmd_map_transfer_2:
  2039.       case cmd_map_transfer_3:
  2040.         { int i = map_index - cmd_map_transfer_0;
  2041.  
  2042.           if_debug1('L', " transfer[%d]", i);
  2043.           rc_unshare_struct(pis->set_transfer.indexed[i], gx_transfer_map,
  2044.                 &st_transfer_map, mem,
  2045.                 return_error(gs_error_VMerror),
  2046.                 "cmd_select_map(transfer)");
  2047.           map = pis->set_transfer.indexed[i];
  2048.           pis->effective_transfer.indexed[i] = map;
  2049.         }
  2050.         break;
  2051.       case cmd_map_ht_transfer:
  2052.         if_debug0('L', " ht transfer");
  2053.         /* Halftone transfer maps are never shared, but */
  2054.         /* rc_unshare_struct is a good way to get one allocated */
  2055.         /* if it hasn't been yet. */
  2056.         pmap = &porder->transfer;
  2057.         cname = "cmd_select_map(ht transfer)";
  2058.         goto alloc;
  2059.       case cmd_map_black_generation:
  2060.         if_debug0('L', " black generation");
  2061.         pmap = &pis->black_generation;
  2062.         cname = "cmd_select_map(black generation)";
  2063.         goto alloc;
  2064.       case cmd_map_undercolor_removal:
  2065.         if_debug0('L', " undercolor removal");
  2066.         pmap = &pis->undercolor_removal;
  2067.         cname = "cmd_select_map(undercolor removal)";
  2068. alloc:        if ( !load )
  2069.           { rc_decrement(*pmap, cname);
  2070.             *pmap = 0;
  2071.         *pmdata = 0;
  2072.         *pcount = 0;
  2073.         return 0;
  2074.           }
  2075.         rc_unshare_struct(*pmap, gx_transfer_map, &st_transfer_map,
  2076.                   mem, return_error(gs_error_VMerror), cname);
  2077.         map = *pmap;
  2078.         break;
  2079.       default:
  2080.         *pmdata = 0;
  2081.         return 0;
  2082.       }
  2083.     map->proc = gs_mapped_transfer;
  2084.     *pmdata = map->values;
  2085.     *pcount = sizeof(map->values);
  2086.     return 0;
  2087. }
  2088.  
  2089. /* Install a halftone order, resizing the bits and levels if necessary. */
  2090. private int
  2091. cmd_install_ht_order(gx_ht_order *porder, const gx_ht_order *pnew,
  2092.   gs_memory_t *mem)
  2093. {    uint *levels = porder->levels;
  2094.     gx_ht_bit *bits = porder->bits;
  2095.  
  2096.     /*
  2097.      * Note that for resizing a byte array, the element size is 1 byte,
  2098.      * not the element size given to alloc_byte_array!
  2099.      */
  2100.     if ( pnew->num_levels > porder->num_levels )
  2101.       { if ( levels == 0 )
  2102.           levels = (uint *)gs_alloc_byte_array(mem, pnew->num_levels,
  2103.                            sizeof(*levels),
  2104.                            "ht order(levels)");
  2105.         else
  2106.           levels = gs_resize_object(mem, levels,
  2107.                     pnew->num_levels * sizeof(*levels),
  2108.                     "ht order(levels)");
  2109.         if ( levels == 0 )
  2110.           return_error(gs_error_VMerror);
  2111.         /* Update porder in case we bail out. */
  2112.         porder->levels = levels;
  2113.         porder->num_levels = pnew->num_levels;
  2114.       }
  2115.     if ( pnew->num_bits > porder->num_bits )
  2116.       { if ( bits == 0 )
  2117.           bits = (gx_ht_bit *)gs_alloc_byte_array(mem, pnew->num_bits,
  2118.                               sizeof(*bits),
  2119.                               "ht order(bits)");
  2120.         else
  2121.           bits = gs_resize_object(mem, bits,
  2122.                       pnew->num_bits * sizeof(*bits),
  2123.                       "ht order(bits)");
  2124.         if ( bits == 0 )
  2125.           return_error(gs_error_VMerror);
  2126.       }
  2127.     *porder = *pnew;
  2128.     porder->levels = levels;
  2129.     porder->bits = bits;
  2130.     porder->full_height = ht_order_full_height(porder);
  2131.     return 0;
  2132. }
  2133.  
  2134. /* Resize the halftone components array if necessary. */
  2135. private int
  2136. cmd_resize_halftone(gx_device_halftone *pdht, uint num_comp,
  2137.   gs_memory_t *mem)
  2138. {    if ( num_comp != pdht->num_comp ) {
  2139.       gx_ht_order_component *pcomp;
  2140.  
  2141.       /*
  2142.        * We must be careful not to shrink or free the components array
  2143.        * before releasing any relevant elements.
  2144.        */
  2145.       if ( num_comp < pdht->num_comp ) {
  2146.         uint i;
  2147.         /* Don't release the default order. */
  2148.         for ( i = pdht->num_comp; i-- > num_comp; )
  2149.           if ( pdht->components[i].corder.bits != pdht->order.bits )
  2150.         gx_ht_order_release(&pdht->components[i].corder, mem, true);
  2151.         if ( num_comp == 0 ) {
  2152.           gs_free_object(mem, pdht->components, "cmd_resize_halftone");
  2153.           pcomp = 0;
  2154.         } else {
  2155.           pcomp = gs_resize_object(mem, pdht->components, num_comp,
  2156.                        "cmd_resize_halftone");
  2157.           if ( pcomp == 0 ) {
  2158.         pdht->num_comp = num_comp;    /* attempt consistency */
  2159.         return_error(gs_error_VMerror);
  2160.           }
  2161.         }
  2162.       } else {
  2163.         /* num_comp > pdht->num_comp */
  2164.         if ( pdht->num_comp == 0 )
  2165.           pcomp = gs_alloc_struct_array(mem, num_comp,
  2166.                         gx_ht_order_component,
  2167.                         &st_ht_order_component_element,
  2168.                         "cmd_resize_halftone");
  2169.         else
  2170.           pcomp = gs_resize_object(mem, pdht->components, num_comp,
  2171.                        "cmd_resize_halftone");
  2172.         if ( pcomp == 0 )
  2173.           return_error(gs_error_VMerror);
  2174.         memset(&pcomp[pdht->num_comp], 0,
  2175.            sizeof(*pcomp) * (num_comp - pdht->num_comp));
  2176.       }
  2177.       pdht->num_comp = num_comp;
  2178.       pdht->components = pcomp;
  2179.     }
  2180.     return 0;
  2181. }
  2182.  
  2183. /* ------ Path operations ------ */
  2184.  
  2185. /* Decode a path segment. */
  2186. private int
  2187. clist_decode_segment(gx_path *ppath, int op, fixed vs[6],
  2188.   gs_fixed_point *ppos, int x0, int y0, segment_notes notes)
  2189. {    fixed px = ppos->x - int2fixed(x0);
  2190.     fixed py = ppos->y - int2fixed(y0);
  2191.     int code;
  2192. #define A vs[0]
  2193. #define B vs[1]
  2194. #define C vs[2]
  2195. #define D vs[3]
  2196. #define E vs[4]
  2197. #define F vs[5]
  2198.  
  2199.     switch ( op )
  2200.        {
  2201.     case cmd_opv_rmoveto:
  2202.         code = gx_path_add_point(ppath, px += A, py += B);
  2203.         break;
  2204.     case cmd_opv_rlineto:
  2205.         code = gx_path_add_line_notes(ppath, px += A, py += B, notes);
  2206.         break;
  2207.     case cmd_opv_hlineto:
  2208.         code = gx_path_add_line_notes(ppath, px += A, py, notes);
  2209.         break;
  2210.     case cmd_opv_vlineto:
  2211.         code = gx_path_add_line_notes(ppath, px, py += A, notes);
  2212.         break;
  2213.     case cmd_opv_rrcurveto: /* a b c d e f => a b a+c b+d a+c+e b+d+f */
  2214.         E += (C += A);
  2215.         F += (D += B);
  2216. curve:        code = gx_path_add_curve_notes(ppath, px + A, py + B,
  2217.                            px + C, py + D,
  2218.                            px + E, py + F, notes);
  2219.         px += E, py += F;
  2220.         break;
  2221.     case cmd_opv_hvcurveto:    /* a b c d => a 0 a+b c a+b c+d */
  2222. hvc:        F = C + D, D = C, E = C = A + B, B = 0;
  2223.         goto curve;
  2224.     case cmd_opv_vhcurveto:    /* a b c d => 0 a b a+c b+d a+c */
  2225. vhc:        E = B + D, F = D = A + C, C = B, B = A, A = 0;
  2226.         goto curve;
  2227.     case cmd_opv_nrcurveto:    /* a b c d => 0 0 a b a+c b+d */
  2228.         F = B + D, E = A + C, D = B, C = A, B = A = 0;
  2229.         goto curve;
  2230.     case cmd_opv_rncurveto:    /* a b c d => a b a+c b+d a+c b+d */
  2231.         F = D += B, E = C += A;
  2232.         goto curve;
  2233.     case cmd_opv_rmlineto:
  2234.         if ( (code = gx_path_add_point(ppath, px += A, py += B)) < 0 )
  2235.           break;
  2236.         code = gx_path_add_line_notes(ppath, px += C, py += D, notes);
  2237.         break;
  2238.     case cmd_opv_rm2lineto:
  2239.         if ( (code = gx_path_add_point(ppath, px += A, py += B)) < 0 ||
  2240.              (code = gx_path_add_line_notes(ppath, px += C, py += D,
  2241.                             notes)) < 0
  2242.            )
  2243.           break;
  2244.         code = gx_path_add_line_notes(ppath, px += E, py += F, notes);
  2245.         break;
  2246.     case cmd_opv_vqcurveto:    /* a b => VH a b TS(a,b) TS(b,a) */
  2247.         if ( (A ^ B) < 0 )
  2248.           C = -B, D = -A;
  2249.         else
  2250.           C = B, D = A;
  2251.         goto vhc;
  2252.     case cmd_opv_hqcurveto:    /* a b => HV a TS(a,b) b TS(b,a) */
  2253.         if ( (A ^ B) < 0 )
  2254.           D = -A, C = B, B = -B;
  2255.         else
  2256.           D = A, C = B;
  2257.         goto hvc;
  2258.     case cmd_opv_rm3lineto:
  2259.         if ( (code = gx_path_add_point(ppath, px += A, py += B)) < 0 ||
  2260.              (code = gx_path_add_line_notes(ppath, px += C, py += D,
  2261.                             notes)) < 0 ||
  2262.              (code = gx_path_add_line_notes(ppath, px += E, py += F,
  2263.                             notes)) < 0
  2264.            )
  2265.           break;
  2266.         code = gx_path_add_line_notes(ppath, px -= C, py -= D, notes);
  2267.         break;
  2268.     case cmd_opv_closepath:
  2269.         code = gx_path_close_subpath(ppath);
  2270.         gx_path_current_point(ppath, (gs_fixed_point *)vs);
  2271.         px = A, py = B;
  2272.         break;
  2273.     default:
  2274.         return_error(gs_error_rangecheck);
  2275.        }
  2276. #undef A
  2277. #undef B
  2278. #undef C
  2279. #undef D
  2280. #undef E
  2281. #undef F
  2282.     ppos->x = px + int2fixed(x0);
  2283.     ppos->y = py + int2fixed(y0);
  2284.     return code;
  2285. }
  2286.